In [ ]:
import tensorflow as tf
from tensorflow import keras
from keras.layers import Input, Conv2D, Activation, Add, UpSampling2D, BatchNormalization
from keras.models import Model
from keras.optimizers import Adam
import numpy as np
import os
import pickle
from tensorflow.keras.preprocessing.image import img_to_array, load_img
from io import BytesIO
from PIL import Image
import matplotlib.pyplot as plt
import math
global max_images_to_import
#max_images_to_import = 10
# change to 10,000 to increase the accuracy:
#max_images_to_import = 10000
max_images_to_import = 10000
DropOut = .7
#show_image_generation_per_number = 20
#show_image_generation_per_number = 1
#show_image_generation_per_number = 100
show_image_generation_per_number = 700
# Constants
IMG_HEIGHT = 256
IMG_WIDTH = 256
CHANNELS = 3
BATCH_SIZE = 1
EPOCHS = 10
LAMBDA = 10 # For cycle consistency loss
import pickle
from PIL import Image
from io import BytesIO
import numpy as np
import matplotlib.pyplot as plt
# Function to load data from pickle file
def load_images(pickle_file, max_images=max_images_to_import):
with open(pickle_file, 'rb') as f:
data = pickle.load(f)
images = []
for i, (key, value) in enumerate(data.items()):
if i >= max_images: # Only load up to max_images images
break
image = Image.open(BytesIO(value))
image_array = img_to_array(image)
image_array = image_array / 255.0
#print(image_array.dtype, image_array.min(), image_array.max())
images.append(image_array)
return images
monet_images = load_images( "/content/drive/My Drive/GANs/Painter/all_monet.pickle")
photo_images = load_images("/content/drive/My Drive/GANs/Painter/all_photo.pickle")
import matplotlib.pyplot as plt
import math
import random
def display_images(images, title, num_images_to_display=10):
num_images_to_display = min(num_images_to_display, len(images))
selected_images = random.sample(images, num_images_to_display)
cols = 5
rows = math.ceil(num_images_to_display / cols)
fig, axes = plt.subplots(rows, cols, figsize=(20, 4*rows))
fig.suptitle(title, fontsize=16)
if rows * cols != 1:
axes = axes.flatten()
else:
axes = [axes]
for i, image in enumerate(selected_images):
axes[i].imshow(image)
axes[i].axis('off')
for ax in axes[num_images_to_display:]:
ax.axis('off')
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()
display_images(photo_images, "Randomly Selected Photo Images")
print()
print()
print()
display_images(monet_images, "Randomly Selected Monet Images")
def decode_image(image):
#image = tf.image.decode_jpeg(image, channels=3)
image_tensor = tf.cast(image, tf.float32)
min_val = tf.reduce_min(image_tensor)
max_val = tf.reduce_max(image_tensor)
image_tensor = (image_tensor - min_val) / (max_val - min_val)
image_tensor = tf.reshape(image_tensor, [1, 256, 256, 3])
return image_tensor
# Convert the lists to TensorFlow datasets
photo_ds = tf.data.Dataset.from_tensor_slices(photo_images)
monet_ds = tf.data.Dataset.from_tensor_slices(monet_images)
# Apply the decode_image function using the .map() method
photo_ds = photo_ds.map(lambda x: decode_image(x))
monet_ds = monet_ds.map(lambda x: decode_image(x))
